import CRC from "./CRC16.js";


/**
 * 蓝牙升级固件
 */

function updateFile(dataArray) {
	const chunkSize = 128 // 蓝牙传输一般最大为128字节/包
	let offset = 0

	function sendChunk() {
		if (offset >= dataArray.length) {
			console.log('固件发送完成')
			return
		}
		const chunk = dataArray.slice(offset, offset + chunkSize)
		uni.writeBLECharacteristicValue({
			deviceId,
			serviceId,
			characteristicId,
			value: chunk.buffer,
			success: function(res) {
				console.log(`发送进度: ${offset}/${dataArray.length}`)
				offset += chunkSize
				setTimeout(sendChunk, 50) // 控制发送间隔，保证接收方处理时间
			},
			fail: function(err) {
				console.error('发送失败', err)
			}
		})
	}

	sendChunk()


}




//写入二进制
function WriteBase(deviceId, value, callback) {
	var serviceId = getApp().globalData.bleObj.serviceId;
	var characteristicId = getApp().globalData.bleObj.characteristicId;
	uni.writeBLECharacteristicValue({
		// 这里的 deviceId 需要在 getBluetoothDevices 或 onBluetoothDeviceFound 接口中获取
		deviceId,
		// 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
		serviceId,
		// 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
		characteristicId,
		// 这里的value是ArrayBuffer类型
		value: value,
		success(res) {
			if (res.errCode == 0 || res.errno == 0) {
				if (callback) {
					callback(res);
				}
			} else {
				console.log(res, '写入二进制success');
			}
		},
		fail(res) {
			console.log(res, '写入二进制fail');
		}
	})
}

//写入读取命令03
function writeStrToRead(str, callback, isAuto = true) {
	var deviceId = getApp().globalData.bleObj.deviceId;
	var state = getApp().globalData.bleObj.state;
	if (deviceId != '' && state) {
		var command = new Uint8Array(str.match(/[\da-f]{2}/gi).map(function(h) {
			return parseInt(h, 16)
		}));
		WriteBase(deviceId, command.buffer, function(res) {
			if (callback) {
				callback(res);
			}
		});
	} else {
		if (!isAuto) {
			//msg(language.b16);
		}
	}
}

//写入读取命令03
function writeToRead(start, len, callback, isAuto = true) {
	var deviceId = getApp().globalData.bleObj.deviceId;
	var state = getApp().globalData.bleObj.state;
	if (deviceId != '' && state) {
		var command = readCommand(start, len);
		WriteBase(deviceId, command, function(res) {
			if (callback) {
				callback(res);
			}
		});
	} else {
		if (!isAuto) {
			//msg(language.b16);
		}
	}
}

//写入写命令06
function writeToWrite(start, value, callback) {
	var deviceId = getApp().globalData.bleObj.deviceId;
	var state = getApp().globalData.bleObj.state;
	if (deviceId != '' && state) {
		var command = writeCommand(start, value);
		console.log('发送Hex:', command);
		WriteBase(deviceId, command, function(res) {
			if (callback) {
				callback(res);
			}
		});
	} else {
		console.log('发送指令失败');
	}
}

const top = '01';
const read = '03';
const write = '06';

//组装读取命令
function readCommand(start, len) {
	var d = top + read + start + len;
	var crc16 = CRC.ToModbusCRC16(d);
	d = d + crc16;

	var typedArray = new Uint8Array(d.match(/[\da-f]{2}/gi).map(function(h) {
		return parseInt(h, 16)
	}));
	//console.log(typedArray);
	return typedArray.buffer;
}

//组装写入命令
function writeCommand(start, value) {
	var d = top + write + start + value;
	var crc16 = CRC.ToModbusCRC16(d);
	d = d + crc16;

	var typedArray = new Uint8Array(d.match(/[\da-f]{2}/gi).map(function(h) {
		return parseInt(h, 16)
	}));
	//console.log(typedArray);
	return typedArray.buffer;
}

//arrayBuffer转16进制字符串
function ab2hex(buffer) {
	const hexArr = Array.prototype.map.call(
		new Uint8Array(buffer),
		function(bit) {
			return ('00' + bit.toString(16)).slice(-2)
		}
	)
	return hexArr.join('');
}

//验证CRC16
function checkCRC16(str) {
	if (!str) {
		return false;
	}
	str = str.toUpperCase();
	if (str.length < 6) {
		return false;
	}
	var d = str.substr(0, str.length - 4);
	var f = str.substr(str.length - 4, 4);

	var crc16 = CRC.ToModbusCRC16(d);
	if (f == crc16) {
		return true;
	} else {
		return false;
	}
}

//解包
function solutionData(str) {
	str = str.toUpperCase();
	var packages = {};
	packages.top = str.substr(0, 2);
	packages.command = str.substr(2, 2);
	if (packages.command == '03') {
		packages.length = parseInt('0x' + str.substr(4, 2));
		var data = str.substr(6, packages.length * 2);
		packages.data = data;
	} else if (packages.command == '06') {
		packages.start = str.substr(4, 4);
		packages.data = str.substr(8, 4);
	}
	packages.crc16 = str.substr(str.length - 4, 4);
	return packages;
}

//16进制转明文显示
function algorithm(name, v1) {
	name = name.toUpperCase();
	var value = 0;
	var v = parseInt("0x" + v1); // 将16进制字符串转换为整数
	switch (name) {
		// 主数据区
		case 'A000': // CellNum	电芯数量
			value = v;
			break;
		case 'A001': // TempNum	温度数量
			value = v;
			break;
		case 'A002': // Voltage	总电压
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A003': // CurCadc	总电流
			value = parseFloat(((v - 10000) * 0.1).toFixed(1));
			break;
		case 'A004': // PowerW	总功率
			value = parseFloat(((v - 10000) * 0.01).toFixed(2));
			break;
		case 'A005': // BalC	均衡电流
			value = v - 10000;
			break;
		case 'A006': // BalNum	均衡位号
			value = v;
			break;
		case 'A007': // Vmax	单体最高
			value = v;
			break;
		case 'A008': // Vmax_num	单体最高位号
			value = v;
			break;
		case 'A009': // Vmin	单体最低
			value = v;
			break;
		case 'A00A': // Vmin_num	单体最低位号
			value = v;
			break;
		case 'A00B': // Tmax	温度最高
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A00C': // Tmax_num	温度最高位号
			value = v;
			break;
		case 'A00D': // Tmin	温度最低
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A00E': // Tmin_num	温度最低位号
			value = v;
			break;
		case 'A00F': // T_MOS	功率部分温度
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A010': // T_BAL	均衡模块温度
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A011': // RateCAP	额定容量
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A012': // FCC	满充容量
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A013': // RC	剩余容量
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A014': // SOC	剩余电量百分比
			value = v;
			break;
		case 'A015': // SOH	电池健康度
			value = v;
			break;
		case 'A016': // CHG_Rem_Time	预计剩余充电时间
			value = v;
			break;
		case 'A017': // DSG_Rem_Time	预计剩余放电时间
			value = v;
			break;
		case 'A018': // Cycle_L	循环次数低16位
			value = v;
			break;
		case 'A019': // Cycle_H	循环次数高16位
			value = v;
			break;
		case 'A01A': // RunTime_L	运行时间低16位
			value = v;
			break;
		case 'A01B': // RunTime_H	运行时间高16位
			value = v;
			break;
		case 'A01C': // TCAP_L	总循环容量低16位
			value = v;
			break;
		case 'A01D': // TCAP_H	总循环容量高16位
			value = v;
			break;
		case 'A01E': // TOTALKWH_L	累计循环电量
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A01F': // TOTALKWH_H	累计循环电量
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A026': // Protect	电池保护标志位1
			const arr = [
				'电压断线', '温度断线', 'MOS温度高', '压差保护',
				'短路保护', '放电过流2', '放电过流1', '单体欠压',
				'总压欠压', '放电高温', '放电低温', '充电过流',
				'单体过压', '总压过压', '充电高温', '充电低温'
			]
			var v = parseInt("0x" + v1).toString(2);
			var vArray = v.split('').reverse();
			var result = [];
			for (var i = 0; i < 16; i++) {
				var item = vArray[i];
				if (item) {
					result.push({
						label: arr[i],
						value: item
					});
				} else {
					result.push({
						label: arr[i],
						value: 0
					});
				}
			}
			return result;
			break;
		case 'A027': // Protect2	电池保护标志位2
			value = v;
			break;
		case 'A028': // Alarm1	电池告警标志位1
			value = v;
			break;
		case 'A029': // Alarm2	电池告警标志位2
			value = v;
			break;
		case 'A02A': // Status1	电池状态标志位1
			var result = {
				status: ("0x" + v1 & 0x0f).toString(), //电池 状态
				chg: (("0x" + v1 >> 4) & 0x03).toString(), //充电回路
				dis: (("0x" + v1 >> 6) & 0x03).toString(), //放电回路
				hot: (("0x" + v1 >> 8) & 0x03).toString(), //加热回路
				low: (("0x" + v1 >> 10) & 0x03).toString(), //低电量
			}
			return result;
			break;
		case 'A02B': // status2	电池状态标志位2
			value = v;
			break;
		case 'A02C': // YM	年月
			value = v;
			break;
		case 'A02D': // DH	日时
			value = v;
			break;
		case 'A02E': // MM	分秒
			value = v;
			break;

			// 单体电压 VCELL1-VCELL24
		case 'A100': // VCELL1	第1串电压
		case 'A101': // VCELL2	第2串电压
		case 'A102': // VCELL3	第3串电压
		case 'A103': // VCELL4	第4串电压
		case 'A104': // VCELL5	第5串电压
		case 'A105': // VCELL6	第6串电压
		case 'A106': // VCELL7	第7串电压
		case 'A107': // VCELL8	第8串电压
		case 'A108': // VCELL9	第9串电压
		case 'A109': // VCELL10	第10串电压
		case 'A10A': // VCELL11	第11串电压
		case 'A10B': // VCELL12	第12串电压
		case 'A10C': // VCELL13	第13串电压
		case 'A10D': // VCELL14	第14串电压
		case 'A10E': // VCELL15	第15串电压
		case 'A10F': // VCELL16	第16串电压
		case 'A110': // VCELL17	第17串电压
		case 'A111': // VCELL18	第18串电压
		case 'A112': // VCELL19	第19串电压
		case 'A113': // VCELL20	第20串电压
		case 'A114': // VCELL21	第21串电压
		case 'A115': // VCELL22	第22串电压
		case 'A116': // VCELL23	第23串电压
		case 'A117': // VCELL24	第24串电压
			value = v;
			break;

			// 温度 TEMP1-TEMP6
		case 'A300': // TEMP1	第1个温度
		case 'A301': // TEMP2	第2个温度
		case 'A302': // TEMP3	第3个温度
		case 'A303': // TEMP4	第4个温度
		case 'A304': // TEMP5	第5个温度
		case 'A305': // TEMP6	第6个温度
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;

			// 预留字段
		case 'A020': // NC	预留
		case 'A021': // NC	预留
		case 'A022': // NC	预留
		case 'A023': // NC	预留
		case 'A024': // NC	预留
		case 'A025': // NC	预留
			value = parseFloat((v * 0.1).toFixed(1));
			break;

		case 'A500': // 电池串数
			value = v;
			break;
		case 'A501': // 温度数量
			value = v;
			break;
		case 'A502': // 电池容量
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A503': // 电池类型
			value = v;
			break;
		case 'A504': // 电池ID
			value = v;
			break;
		case 'A505': // 485_1站地址
			value = v;
			break;
		case 'A506': // 485_2站地址
			value = v;
			break;
		case 'A507': // 485_1波特率
			value = v * 100;
			break;
		case 'A508': // 485_2波特率
			value = v * 100;
			break;
		case 'A509': // CAN1_波特率
			value = v;
			break;
		case 'A50A': // CAN1_波特率
			value = v;
			break;
		case 'A50B': // 请求充电电压
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A50C': // 请求充电电流
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A50D': // 充电电流策略
			value = v;
			break;
		case 'A50E': // 开关量标志位
			value = v;
			break;
		case 'A50F': // 控制策略选择
			value = v;
			break;
		case 'A510': // 充电回路使能
			value = v;
			break;
		case 'A511': // 放电回路使能
			value = v;
			break;
		case 'A512': // 加热回路使能
			value = v;
			break;
		case 'A513': // 蜂鸣器回路使能
			value = v;
			break;
		case 'A600': // 总压过压保护
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A601': // 总压过压保护延时
			value = v;
			break;
		case 'A602': // 总压过压释放
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A603': // 总压过压释放延时
			value = v;
			break;
		case 'A604': // 单体过压保护
			value = v;
			break;
		case 'A605': // 单体过压保护延时
			value = v;
			break;
		case 'A606': // 单体过压释放
			value = v;
			break;
		case 'A607': // 单体过压释放延时
			value = v;
			break;
		case 'A608': // 总压欠压保护
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A609': // 总压欠压保护延时
			value = v;
			break;
		case 'A60A': // 总压欠压释放
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A60B': // 总压欠压释放延时
			value = v;
			break;
		case 'A60C': // 单体欠压保护
			value = v;
			break;
		case 'A60D': // 单体欠压保护延时
			value = v;
			break;
		case 'A60E': // 单体欠压释放
			value = v;
			break;
		case 'A60F': // 单体欠压释放延时
			value = v;
			break;
		case 'A610': // 压差保护
			value = v;
			break;
		case 'A611': // 压差保护延时
			value = v;
			break;
		case 'A612': // 压差保护释放
			value = v;
			break;
		case 'A613': // 压差保护释放延时
			value = v;
			break;
		case 'A614': // 放电高温保护
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A615': // 放电高温保护延时
			value = v;
			break;
		case 'A616': // 放电高温释放
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A617': // 放电高温释放延时
			value = v;
			break;
		case 'A618': // 充电高温保护
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A619': // 充电高温保护延时
			value = v;
			break;
		case 'A61A': // 充电高温释放
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A61B': // 充电高温释放延时
			value = v;
			break;
		case 'A61C': // 放电低温保护
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A61D': // 放电低温保护延时
			value = v;
			break;
		case 'A61E': // 放电低温释放
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A61F': // 放电低温释放延时
			value = v;
			break;
		case 'A620': // 充电低温保护
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A621': // 充电低温保护延时
			value = v;
			break;
		case 'A622': // 充电低温释放
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A623': // 充电低温释放延时
			value = v;
			break;
		case 'A624': // MOS高温保护
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A625': // MOS高温保护延时
			value = v;
			break;
		case 'A626': // MOS高温释放
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A627': // MOS高温释放延时
			value = v;
			break;
		case 'A628': // 充电过流保护
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A629': // 充电过流保护延时
			value = v;
			break;
		case 'A62A': // 充电过流释放
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A62B': // 充电过流释放延时
			value = v;
			break;
		case 'A62C': // 放电过流保护
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A62D': // 放电过流保护延时
			value = v;
			break;
		case 'A62E': // 放电过流释放
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A62F': // 放电过流释放延时
			value = v;
			break;
		case 'A630': // 放电过流保护
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A631': // 放电过流保护延时
			value = v;
			break;
		case 'A632': // 放电过流释放
			value = parseFloat((v * 0.1).toFixed(1));
			break;
		case 'A633': // 放电过流释放延时
			value = v;
			break;
		case 'A634': // 短路保护尝试次数
			value = v;
			break;
		case 'A635': // 短路保护释放延时
			value = v;
			break;
		case 'A636': // 均衡开启策略
			value = v;
			break;
		case 'A637': // 均衡最大电流
			value = v;
			break;
		case 'A638': // 均衡开启压差
			value = v;
			break;
		case 'A639': // 均衡开启最高电压
			value = v;
			break;
		case 'A63A': // 均衡开启最低电压
			value = v;
			break;
		case 'A63B': // 均衡开启最高温度
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A63C': // 均衡开启最低温度
			value = parseFloat(((v - 400) * 0.1).toFixed(1));
			break;
		case 'A63D': // 均衡法拉电容高点
			value = v;
			break;
		case 'A63E': // 均衡法拉电容低点
			value = v;
			break;
		case 'A63F': // 均衡母线电压高点
			value = v;
			break;
		case 'A640': // 均衡母线电压低点
			value = v;
			break;
		case 'A641': // 放电均衡PWM高点
			value = v;
			break;
		case 'A642': // 放电均衡PWM低点
			value = v;
			break;
		case 'A643': // 放电均衡周期
			value = v;
			break;
		case 'A644': // 放电均衡增益调节值
			value = v;
			break;
		case 'A645': // 充电均衡PWM高点
			value = v;
			break;
		case 'A646': // 充电均衡PWM低点
			value = v;
			break;
		case 'A647': // 充电均衡周期
			value = v;
			break;
		case 'A648': // 充电均衡增益调节值
			value = v;
			break;
		case 'A649': // 休眠使能
			value = v;
			break;
		case 'A64A': // 快速休眠电压
			value = v;
			break;
		case 'A64B': // 快速休眠延时
			value = v;
			break;
		case 'A64C': // 中速休眠电压
			value = v;
			break;
		case 'A64D': // 中速休眠延时
			value = v;
			break;
		case 'A64E': // 慢速休眠电压
			value = v;
			break;
		case 'A64F': // 慢速休眠延时
			value = v;
			break;
		case 'A700': // 电压基准
			value = v;
			break;
		case 'A701': // 电流增益系数
			value = v;
			break;
		case 'A702': // 静态电流偏置值
			value = v;
			break;
		case 'A703': // 电流屏蔽值
			value = v;
			break;
		case 'A704': // 运行自耗电
			value = v;
			break;
		case 'A705': // 充电增益
			value = v;
			break;
		case 'A706': // 一阶放电增益
			value = v;
			break;
		case 'A707': // 二阶放电增益
			value = v;
			break;
		case 'A708': // 低电量阈值
			value = v;
			break;
		case 'A709': // 低电量阈值
			value = v;
			break;
		case 'A70A': // 迭代容量上限
			value = v;
			break;
		case 'A70B': // 迭代容量下限
			value = v;
			break;
		case 'A70C': // 高点满充值
			value = v;
			break;
		case 'A70D': // 中点电压值
			value = v;
			break;
		case 'A70E': // 低点放光值
			value = v;
			break;
		case 'A70F': // 充电效能系数
			value = v;
			break;
		case 'A710': // 放电效能系数
			value = v;
			break;
		case 'A711': // 满充容量系数
			value = v;
			break;
		case 'A712': // 循环标定系数
			value = v;
			break;
		case 'A713': // 高低点标定使能
			value = v;
			break;
		case 'A714': // 1%电压标定
			value = v;
			break;
		case 'A715': // 2%电压标定
			value = v;
			break;
		case 'A716': // 3%电压标定
			value = v;
			break;
		case 'A717': // 4%电压标定
			value = v;
			break;
		case 'A718': // 5%电压标定
			value = v;
			break;
		case 'A719': // 95%电压标定
			value = v;
			break;
		case 'A71A': // 96%电压标定
			value = v;
			break;
		case 'A71B': // 97%电压标定
			value = v;
			break;
		case 'A71C': // 98%电压标定
			value = v;
			break;
		case 'A71D': // 99%电压标定
			value = v;
			break;

		default:
			// 对于未定义的寄存器，返回原始值
			value = v;
			break;
	}

	return value;
}
const hexMap = {
	'0': '0000',
	'1': '0001',
	'2': '0010',
	'3': '0011',
	'4': '0100',
	'5': '0101',
	'6': '0110',
	'7': '0111',
	'8': '1000',
	'9': '1001',
	'a': '1010',
	'b': '1011',
	'c': '1100',
	'd': '1101',
	'e': '1110',
	'f': '1111'
};
/**
 * @param {Object} hexStr
 * 
 * 
 */
function hexToBitsFast(hexStr) {
	return hexStr.toLowerCase()
		.split('')
		.map(c => hexMap[c] || '0000')
		.join('');
}

//明文转16进制

//明文转16进制
function encryption(name, value) {
	name = name.toUpperCase();
	var v = 0;
	switch (name) {
		case 'A500': // 电池串数
			v = Math.round(value);
			break;
		case 'A501': // 温度数量
			v = Math.round(value);
			break;
		case 'A502': // 电池容量
			v = Math.round(value * 10);
			break;
		case 'A503': // 电池类型
			v = Math.round(value);
			break;
		case 'A504': // 电池ID
			v = Math.round(value);
			break;
		case 'A505': // 485_1站地址
			v = Math.round(value);
			break;
		case 'A506': // 485_2站地址
			v = Math.round(value);
			break;
		case 'A507': // 485_1波特率
			v = Math.round(value / 100);
			break;
		case 'A508': // 485_2波特率
			v = Math.round(value / 100);
			break;
		case 'A509': // CAN1_波特率
			v = Math.round(value);
			break;
		case 'A50A': // CAN1_波特率
			v = Math.round(value);
			break;
		case 'A50B': // 请求充电电压
			v = Math.round(value * 10);
			break;
		case 'A50C': // 请求充电电流
			v = Math.round(value * 10);
			break;
		case 'A50D': // 充电电流策略
			v = Math.round(value);
			break;
		case 'A50E': // 开关量标志位
			v = Math.round(value);
			break;
		case 'A50F': // 控制策略选择
			v = Math.round(value);
			break;
		case 'A510': // 充电回路使能
			v = Math.round(value);
			break;
		case 'A511': // 放电回路使能
			v = Math.round(value);
			break;
		case 'A512': // 加热回路使能
			v = Math.round(value);
			break;
		case 'A513': // 蜂鸣器回路使能
			v = Math.round(value);
			break;
		case 'A600': // 总压过压保护
			v = Math.round(value * 10);
			break;
		case 'A601': // 总压过压保护延时
			v = Math.round(value);
			break;
		case 'A602': // 总压过压释放
			v = Math.round(value * 10);
			break;
		case 'A603': // 总压过压释放延时
			v = Math.round(value);
			break;
		case 'A604': // 单体过压保护
			v = Math.round(value);
			break;
		case 'A605': // 单体过压保护延时
			v = Math.round(value);
			break;
		case 'A606': // 单体过压释放
			v = Math.round(value);
			break;
		case 'A607': // 单体过压释放延时
			v = Math.round(value);
			break;
		case 'A608': // 总压欠压保护
			v = Math.round(value * 10);
			break;
		case 'A609': // 总压欠压保护延时
			v = Math.round(value);
			break;
		case 'A60A': // 总压欠压释放
			v = Math.round(value * 10);
			break;
		case 'A60B': // 总压欠压释放延时
			v = Math.round(value);
			break;
		case 'A60C': // 单体欠压保护
			v = Math.round(value);
			break;
		case 'A60D': // 单体欠压保护延时
			v = Math.round(value);
			break;
		case 'A60E': // 单体欠压释放
			v = Math.round(value);
			break;
		case 'A60F': // 单体欠压释放延时
			v = Math.round(value);
			break;
		case 'A610': // 压差保护
			v = Math.round(value);
			break;
		case 'A611': // 压差保护延时
			v = Math.round(value);
			break;
		case 'A612': // 压差保护释放
			v = Math.round(value);
			break;
		case 'A613': // 压差保护释放延时
			v = Math.round(value);
			break;
		case 'A614': // 放电高温保护
			v = Math.round(value * 10 + 400);
			break;
		case 'A615': // 放电高温保护延时
			v = Math.round(value);
			break;
		case 'A616': // 放电高温释放
			v = Math.round(value * 10 + 400);
			break;
		case 'A617': // 放电高温释放延时
			v = Math.round(value);
			break;
		case 'A618': // 充电高温保护
			v = Math.round(value * 10 + 400);
			break;
		case 'A619': // 充电高温保护延时
			v = Math.round(value);
			break;
		case 'A61A': // 充电高温释放
			v = Math.round(value * 10 + 400);
			break;
		case 'A61B': // 充电高温释放延时
			v = Math.round(value);
			break;
		case 'A61C': // 放电低温保护
			v = Math.round(value * 10 + 400);
			break;
		case 'A61D': // 放电低温保护延时
			v = Math.round(value);
			break;
		case 'A61E': // 放电低温释放
			v = Math.round(value * 10 + 400);
			break;
		case 'A61F': // 放电低温释放延时
			v = Math.round(value);
			break;
		case 'A620': // 充电低温保护
			v = Math.round(value * 10 + 400);
			break;
		case 'A621': // 充电低温保护延时
			v = Math.round(value);
			break;
		case 'A622': // 充电低温释放
			v = Math.round(value * 10 + 400);
			break;
		case 'A623': // 充电低温释放延时
			v = Math.round(value);
			break;
		case 'A624': // MOS高温保护
			v = Math.round(value * 10 + 400);
			break;
		case 'A625': // MOS高温保护延时
			v = Math.round(value);
			break;
		case 'A626': // MOS高温释放
			v = Math.round(value * 10 + 400);
			break;
		case 'A627': // MOS高温释放延时
			v = Math.round(value);
			break;
		case 'A628': // 充电过流保护
			v = Math.round(value * 10);
			break;
		case 'A629': // 充电过流保护延时
			v = Math.round(value);
			break;
		case 'A62A': // 充电过流释放
			v = Math.round(value * 10);
			break;
		case 'A62B': // 充电过流释放延时
			v = Math.round(value);
			break;
		case 'A62C': // 放电过流保护
			v = Math.round(value * 10);
			break;
		case 'A62D': // 放电过流保护延时
			v = Math.round(value);
			break;
		case 'A62E': // 放电过流释放
			v = Math.round(value * 10);
			break;
		case 'A62F': // 放电过流释放延时
			v = Math.round(value);
			break;
		case 'A630': // 放电过流保护
			v = Math.round(value * 10);
			break;
		case 'A631': // 放电过流保护延时
			v = Math.round(value);
			break;
		case 'A632': // 放电过流释放
			v = Math.round(value * 10);
			break;
		case 'A633': // 放电过流释放延时
			v = Math.round(value);
			break;
		case 'A634': // 短路保护尝试次数
			v = Math.round(value);
			break;
		case 'A635': // 短路保护释放延时
			v = Math.round(value);
			break;
		case 'A636': // 均衡开启策略
			v = Math.round(value);
			break;
		case 'A637': // 均衡最大电流
			v = Math.round(value);
			break;
		case 'A638': // 均衡开启压差
			v = Math.round(value);
			break;
		case 'A639': // 均衡开启最高电压
			v = Math.round(value);
			break;
		case 'A63A': // 均衡开启最低电压
			v = Math.round(value);
			break;
		case 'A63B': // 均衡开启最高温度
			v = Math.round(value * 10 + 400);
			break;
		case 'A63C': // 均衡开启最低温度
			v = Math.round(value * 10 + 400);
			break;
		case 'A63D': // 均衡法拉电容高点
			v = Math.round(value);
			break;
		case 'A63E': // 均衡法拉电容低点
			v = Math.round(value);
			break;
		case 'A63F': // 均衡母线电压高点
			v = Math.round(value);
			break;
		case 'A640': // 均衡母线电压低点
			v = Math.round(value);
			break;
		case 'A641': // 放电均衡PWM高点
			v = Math.round(value);
			break;
		case 'A642': // 放电均衡PWM低点
			v = Math.round(value);
			break;
		case 'A643': // 放电均衡周期
			v = Math.round(value);
			break;
		case 'A644': // 放电均衡增益调节值
			v = Math.round(value);
			break;
		case 'A645': // 充电均衡PWM高点
			v = Math.round(value);
			break;
		case 'A646': // 充电均衡PWM低点
			v = Math.round(value);
			break;
		case 'A647': // 充电均衡周期
			v = Math.round(value);
			break;
		case 'A648': // 充电均衡增益调节值
			v = Math.round(value);
			break;
		case 'A649': // 休眠使能
			v = Math.round(value);
			break;
		case 'A64A': // 快速休眠电压
			v = Math.round(value);
			break;
		case 'A64B': // 快速休眠延时
			v = Math.round(value);
			break;
		case 'A64C': // 中速休眠电压
			v = Math.round(value);
			break;
		case 'A64D': // 中速休眠延时
			v = Math.round(value);
			break;
		case 'A64E': // 慢速休眠电压
			v = Math.round(value);
			break;
		case 'A64F': // 慢速休眠延时
			v = Math.round(value);
			break;
		case 'A700': // 电压基准
			v = Math.round(value);
			break;
		case 'A701': // 电流增益系数
			v = Math.round(value);
			break;
		case 'A702': // 静态电流偏置值
			v = Math.round(value);
			break;
		case 'A703': // 电流屏蔽值
			v = Math.round(value);
			break;
		case 'A704': // 运行自耗电
			v = Math.round(value);
			break;
		case 'A705': // 充电增益
			v = Math.round(value);
			break;
		case 'A706': // 一阶放电增益
			v = Math.round(value);
			break;
		case 'A707': // 二阶放电增益
			v = Math.round(value);
			break;
		case 'A708': // 低电量阈值
			v = Math.round(value);
			break;
		case 'A709': // 迭代容量上限
			v = Math.round(value);
			break;
		case 'A70A': // 迭代容量下限
			v = Math.round(value);
			break;
		case 'A70B': // 高点满充值
			v = Math.round(value);
			break;
		case 'A70C': // 中点电压值
			v = Math.round(value);
			break;
		case 'A70D': // 低点放光值
			v = Math.round(value);
			break;
		case 'A70E': // 充电效能系数
			v = Math.round(value);
			break;
		case 'A70F': // 放电效能系数
			v = Math.round(value);
			break;
		case 'A710': // 满充容量系数
			v = Math.round(value);
			break;
		case 'A711': // 循环标定系数
			v = Math.round(value);
			break;
		case 'A712': // 高低点标定使能
			v = Math.round(value);
			break;
		case 'A713': // 1%电压标定
			v = Math.round(value);
			break;
		case 'A714': // 2%电压标定
			v = Math.round(value);
			break;
		case 'A715': // 3%电压标定
			v = Math.round(value);
			break;
		case 'A716': // 4%电压标定
			v = Math.round(value);
			break;
		case 'A717': // 5%电压标定
			v = Math.round(value);
			break;
		case 'A718': // 95%电压标定
			v = Math.round(value);
			break;
		case 'A719': // 96%电压标定
			v = Math.round(value);
			break;
		case 'A71A': // 97%电压标定
			v = Math.round(value);
			break;
		case 'A71B': // 98%电压标定
			v = Math.round(value);
			break;
		case 'A71C': // 99%电压标定
			v = Math.round(value);
			break;
		default:
			v = 0; // 未知寄存器返回0
			break;
	}
	var v2 = v.toString(16);
	if (v2 == '') {
		return '';
	}
	if (v2.indexOf('-') >= 0) {
		return '';
	}
	//不足4位对齐4位，供modbus协议传递
	if (v2.length == 1) {
		return '000' + v2;
	} else if (v2.length == 2) {
		return '00' + v2;
	} else if (v2.length == 3) {
		return '0' + v2;
	} else if (v2.length == 4) {
		return v2;
	} else {
		return '';
	}
}

export default {
	WriteBase: WriteBase,
	writeStrToRead: writeStrToRead,
	writeToRead: writeToRead,
	writeToWrite: writeToWrite,
	readCommand: readCommand,
	bufferToHex: ab2hex,
	checkCRC16: checkCRC16,
	solutionData: solutionData,
	algorithm: algorithm,
	encryption: encryption,
	writeCommand: writeCommand
}